home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2001 / MacHack 2001.toast / pc / The Hacks / 99 Bottles hack / MyUtils / BigStrings.p < prev    next >
Encoding:
Text File  |  2001-06-23  |  3.4 KB  |  149 lines
  1. unit BigStrings;
  2.  
  3. { This unit allows the creation and use of strings that are larger than 255 characters. }
  4. { Typical Pascal strings have a 'length' byte at position 0 in the 256 character array. }
  5. { These strings have two length bytes (for a max length of 65536 characters) but are }
  6. { typically less. }
  7.  
  8. interface
  9.  
  10.     const
  11.         kBigStringMaxLength = 4096; 
  12.     
  13.     type
  14.         BigString = record
  15.             length: Integer;
  16.             chr: packed array[1..kBigStringMaxLength] of char;
  17.         end;
  18.         BigStringPtr = ^BigString;
  19.  
  20. { Similarities with Strings: }
  21. { 1) Null string: }
  22. {    s := '';                b.length := 0; }
  23.  
  24. { Create/dispose of a new BigString on the heap }
  25.     function NewBigStringPtr: BigStringPtr;
  26.     procedure DisposeBigStringPtr(var b: BigStringPtr);
  27.  
  28. { Convert a string into a big string and conversely }
  29.     procedure StrToBigString(s: String; var b: BigStringPtr);
  30.     procedure BigStringToStr(b: BigStringPtr; var s: String);
  31.  
  32. { Add a string to a big string }    
  33.     procedure BigStrConcat(var b: BigStringPtr; s: String);
  34. { Add a big string to a big string }    
  35.     procedure BigConcat(var b: BigStringPtr; c: BigStringPtr);
  36.  
  37. { Check if a string is equal to a big string }
  38.     function BigStrEqual(b: BigStringPtr; s: String): Boolean;
  39.     
  40. implementation
  41.  
  42.     uses
  43.         Types, Memory;
  44.  
  45.     function NewBigStringPtr: BigStringPtr;
  46.     var
  47.         b: BigStringPtr;
  48.     begin
  49.         b := BigStringPtr(NewPtrClear(SizeOf(BigString)));
  50.         if (b <> nil) then
  51.             b^.length := 0;
  52.         NewBigStringPtr := b;
  53.     end; { NewBigStringPtr }
  54.  
  55.     procedure DisposeBigStringPtr(var b: BigStringPtr);
  56.     begin
  57.         DisposePtr(Ptr(b));
  58.     end; { DisposeBigStringPtr }
  59.     
  60.     procedure StrToBigString(s: String; var b: BigStringPtr);
  61.     var
  62.         i, l: Integer;
  63.     begin
  64.         if b <> nil then begin
  65.             l := Length(s);
  66.             if l > 0 then
  67.                 for i := 1 to l do
  68.                     b^.chr[i] := s[i];
  69.             b^.length := l;
  70.         end; { if b }
  71.     end; { StrToBigString }
  72.  
  73.     procedure BigStringToStr(b: BigStringPtr; var s: String);
  74.     var
  75.         i, l: Integer;
  76.     begin
  77.         if b <> nil then begin
  78.             l := b^.length;
  79.             if l > 0 then begin
  80.                 if l > 255 then
  81.                     l := 255;
  82.                 for i := 1 to l do
  83.                     s[i] := b^.chr[i];
  84. {$push}
  85. {$r-}
  86.                 s[0] := Chr(l);
  87. {$pop}
  88.             end;
  89.         end; { if b }
  90.     end; { BigStringToStr }
  91.  
  92.  
  93.     procedure BigStrConcat(var b: BigStringPtr; s: String);
  94.     var
  95.         i, l: Integer;
  96.     begin
  97.         if b <> nil then begin
  98.             l := Length(s);
  99.             if l > 0 then begin
  100.                 if (b^.length + l) > kBigStringMaxLength then 
  101.                     l := kBigStringMaxLength - b^.length;
  102.                 for i := 1 to l do
  103.                     b^.chr[b^.length + i] := s[i];
  104.                 b^.length := b^.length + l;
  105.             end; { if l > 0 }
  106.         end; { if b }
  107.     end; { BigStrConcat }
  108.     
  109.     procedure BigConcat(var b: BigStringPtr; c: BigStringPtr);
  110.     var
  111.         i, l: Integer;
  112.     begin
  113.         if b <> nil then begin
  114.             l := c^.length;
  115.             if l > 0 then begin
  116.                 if (b^.length + l) > kBigStringMaxLength then 
  117.                     l := kBigStringMaxLength - b^.length;
  118.                 for i := 1 to l do
  119.                     b^.chr[b^.length + i] := c^.chr[i];
  120.                 b^.length := b^.length + l;
  121.             end; { if l > 0 }
  122.         end; { if b }
  123.     end; { BigConcat }
  124.     
  125.     function BigStrEqual(b: BigStringPtr; s: String): Boolean;
  126.     var
  127.         result, match: Boolean;
  128.         i, l: Integer;
  129.     begin
  130.         result := false;
  131.         l := Length(s);
  132.         if (l = b^.length) then begin
  133.             match := true;
  134.             i := 1;
  135.             while match do begin
  136.                 match := s[i] = b^.chr[i];
  137.                 if match then
  138.                     i := i + 1;
  139.                 if i > l then
  140.                     match := false; { to leave the while loop }
  141.             end; { while }
  142.             
  143.             if i > l then
  144.                 result := true; { we have a match! }
  145.         end;
  146.         BigStrEqual := result;
  147.     end; { BigStrEqual }
  148.  
  149. end. { BigStrings }